home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / Book Chapters / 14 - Glypha III / Glypha III source / GlyphaIII Code ƒ / SetUpTakeDown.c < prev    next >
Text File  |  1995-03-24  |  22KB  |  562 lines
  1.  
  2. //============================================================================
  3. //----------------------------------------------------------------------------
  4. //                                SetUpTakeDown.c
  5. //----------------------------------------------------------------------------
  6. //============================================================================
  7.  
  8. // The below functions are grouped here becuase they are only called once when…
  9. // Glypha either starts up or quits.
  10.  
  11. #include "Externs.h"
  12. #include <Palettes.h>                    // Need "Palettes.h" for the depth calls.
  13.  
  14.  
  15. #define kHandPictID                128        // These are all the resource ID's for…
  16. #define kHandMaskID                129        // the various PICT's were going to…
  17. #define kBackgroundPictID        130        // load up into offscreen pixmaps and…
  18. #define kHelpPictID                131        // offscreen bitmaps.
  19. #define kObeliskPictID            134
  20. #define kPlayerPictID            135
  21. #define kPlayerMaskID            136
  22. #define kNumberPictID            137
  23. #define kIdlePictID                138
  24. #define kEnemyWalkPictID        139
  25. #define kEnemyFlyPictID            140
  26. #define kEnemyWalkMaskID        141
  27. #define kEnemyFlyMaskID            142
  28. #define kFlamePictID            143
  29. #define kEggPictID                144
  30. #define kEggMaskID                145
  31. #define kPlatformPictID            146
  32. #define kEyePictID                147
  33. #define kEyeMaskID                148
  34.  
  35.  
  36. Boolean DoWeHaveColor (void);            // Prototypes to below functions that are…
  37. Boolean DoWeHaveSystem605 (void);        // called locally.  These aren't really…
  38. short WhatsOurDepth (void);                // necessary, but I don't enjoy relying on…
  39. Boolean CanWeDisplay8Bit (GDHandle);    // the compiler to second guess me.
  40. void SwitchToDepth (short, Boolean);
  41.  
  42.  
  43. short        wasDepth;                    // Only global variable defined here.
  44.  
  45.                                         // Other global variables defined elsewhere.
  46. extern    Rect        mainWindowRect, backSrcRect, workSrcRect, obSrcRect, playerSrcRect;
  47. extern    Rect        numberSrcRect, idleSrcRect, enemyWalkSrcRect, enemyFlySrcRect;
  48. extern    Rect        obeliskRects[4], playerRects[11], numbersSrc[11], numbersDest[11];
  49. extern    Rect        platformRects[6], touchDownRects[6], enemyRects[24], handSrcRect;
  50. extern    Rect        flameSrcRect, flameDestRects[2], flameRects[4], platformCopyRects[9];
  51. extern    Rect        enemyInitRects[5], eggSrcRect, platformSrcRect, helpSrcRect;
  52. extern    Rect        handRects[2], grabZone, eyeSrcRect, eyeRects[4];
  53. extern    GDHandle    thisGDevice;
  54. extern    CGrafPtr    backSrcMap, workSrcMap, obeliskSrcMap, playerSrcMap;
  55. extern    CGrafPtr    numberSrcMap, idleSrcMap, enemyWalkSrcMap, enemyFlySrcMap;
  56. extern    CGrafPtr    flameSrcMap, eggSrcMap, platformSrcMap, helpSrcMap, handSrcMap;
  57. extern    CGrafPtr    eyeSrcMap;
  58. extern    GrafPtr        playerMaskMap, enemyWalkMaskMap, enemyFlyMaskMap, eggMaskMap;
  59. extern    GrafPtr        handMaskMap, eyeMaskMap;
  60. extern    WindowPtr    mainWindow;
  61. extern    RgnHandle    playRgn;
  62. extern    MenuHandle    appleMenu, gameMenu, optionsMenu;
  63. extern    long        theScore, wasTensOfThousands;
  64. extern    short        numLedges, beginOnLevel, levelOn, livesLeft;
  65. extern    Boolean        quitting, playing, pausing, switchedOut, canPlay, whichList;
  66. extern    Boolean        helpOpen, scoresOpen, openTheScores;
  67.  
  68.  
  69. //==============================================================  Functions
  70. //--------------------------------------------------------------  ToolBoxInit
  71.  
  72. // Here's the first function you ever call in Glypha (or any Mac program for…
  73. // that matter).  The calls herein MUST be called before you do anything else.
  74. // Otherwise, you'll get all sorts of System Errors.
  75.  
  76. void ToolBoxInit (void)
  77. {
  78.     InitGraf(&qd.thePort);        // Initialize QuickDraw variables for our program.
  79.     InitFonts();                // Initialize fonts.
  80.     FlushEvents(everyEvent, 0);    // Clear event queue of any pending events.
  81.     InitWindows();                // Initialize the Window Manager.
  82.     InitMenus();                // Ditto for the Menu Manager.
  83.     TEInit();                    // blah, blah Text Edit.
  84.     InitDialogs(0L);            // blah, blah Dialog Manager.
  85.     InitCursor();                // Set the cursor to the arrow cursor and init.
  86.     
  87.     MaxApplZone();                // Grab application memory.
  88.     
  89.     MoreMasters();                // Allocate a block of master pointers.
  90.     MoreMasters();                // And allocate more.
  91.     MoreMasters();                // And more.
  92.     MoreMasters();                // Hey, lets do it again too.
  93.     
  94.     switchedOut = FALSE;        // We "should" be the foreground app at this time.
  95.     GetDateTime((unsigned long *)&qd.randSeed);        // Randomize random seed.
  96. }
  97.  
  98. //--------------------------------------------------------------  DoWeHaveColor  
  99.  
  100. // Simple function that returns TRUE if we're running on a Mac that…
  101. // is running Color Quickdraw.
  102.  
  103. Boolean DoWeHaveColor (void)
  104. {
  105.     SysEnvRec        thisWorld;
  106.     
  107.     SysEnvirons(2, &thisWorld);        // Call the old SysEnvirons() function.
  108.     return (thisWorld.hasColorQD);    // And return whether it has Color QuickDraw.
  109. }
  110.  
  111. //--------------------------------------------------------------  DoWeHaveSystem605  
  112.  
  113. // Another simple "environment" function.  Returns TRUE if the Mac we're running…
  114. // on has System 6.0.5 or more recent.  (6.0.5 introduced the ability to switch…
  115. // color depths.)
  116.  
  117. Boolean DoWeHaveSystem605 (void)
  118. {
  119.     SysEnvRec        thisWorld;
  120.     Boolean            haveIt;
  121.     
  122.     SysEnvirons(2, &thisWorld);        // Call the old SysEnvirons() function.
  123.     if (thisWorld.systemVersion >= 0x0605)
  124.         haveIt = TRUE;                // Check the System version for 6.0.5…
  125.     else                            // or more recent
  126.         haveIt = FALSE;
  127.     return (haveIt);
  128. }
  129.  
  130. //--------------------------------------------------------------  WhatsOurDepth  
  131.  
  132. // Function returns the current bit depth.  For example, 4 = 16 colors, 8 = 256…
  133. // colors.  Note, this function assumes System 6.0.5 or more recent and Color…
  134. // Quickdraw capable.  You should haved called the previous two functions before…
  135. // attempting this call.
  136.  
  137. short WhatsOurDepth (void)
  138. {
  139.     short            thisDepth;
  140.     char            wasState;
  141.     
  142.     if (thisGDevice != 0L)                            // Make sure we have device handle.
  143.     {
  144.         wasState = HGetState((Handle)thisGDevice);    // Remember the handle's state.
  145.         HLock((Handle)thisGDevice);                    // Lock the device handle down.
  146.                                                     // Get it's depth (pixelSize).
  147.         thisDepth = (**(**thisGDevice).gdPMap).pixelSize;
  148.         HSetState((Handle)thisGDevice, wasState);    // Restore handle's state.
  149.     }
  150.     else
  151.         RedAlert("\pUnknown Error.");                // Post generic error message.
  152.     
  153.     return (thisDepth);                                // Return screen depth.
  154. }
  155.  
  156. //--------------------------------------------------------------  CanWeDisplay8Bit  
  157.  
  158. // Simple function that returns TRUE if the current device (monitor) is…
  159. // capable of displaying 256 colors (or grays).  This function, the one above,…
  160. // and many following functions assume we have System 6.0.5 or more recent and…
  161. // are capable of Color QuickDraw.
  162.  
  163. Boolean CanWeDisplay8Bit (GDHandle theDevice)
  164. {
  165.     short        canDepth;
  166.     Boolean        canDo;
  167.     
  168.     canDo = FALSE;        // Assume intially that we can't display 8 bit.
  169.                         // Call HasDepth() to see if monitor supports 8 bit.
  170.     canDepth = HasDepth(theDevice, 8, 1, 0);
  171.     if (canDepth != 0)    // If HasDepth() returned anything other than 0…
  172.         canDo = TRUE;    // we can indeed switch it to 8 bit.
  173.     
  174.     return (canDo);        // Return the result.
  175. }
  176.  
  177. //--------------------------------------------------------------  SwitchToDepth
  178.  
  179. // This handy function forces the device (monitor) in question to switch…
  180. // to a specific depth.  We'll call this function if we need to switch to…
  181. // 8-bit (256 colors).  We should have called the above function first in…
  182. // order to be sure that we CAN in fact switch this monitor to 8-bit.
  183.  
  184. void SwitchToDepth (short newDepth, Boolean doColor)
  185. {
  186.     OSErr            theErr;
  187.     short            colorFlag;
  188.     char            tagByte;
  189.     
  190.     if (doColor)                    // We can switch to either colors or grays.
  191.         colorFlag = 1;
  192.     else
  193.         colorFlag = 0;
  194.     
  195.     if (thisGDevice != 0L)            // Make sure we have a device.
  196.     {                                // Remember handle's state (as usual).
  197.         tagByte = HGetState((Handle)thisGDevice);
  198.         HLock((Handle)thisGDevice);    // Lock it.
  199.                                     // Call SetDepth() (System 6.0.5 or more recent).
  200.         theErr = SetDepth(thisGDevice, newDepth, 1, colorFlag);
  201.                                     // Restore handle's state.
  202.         HSetState((Handle)thisGDevice, tagByte);
  203.         if (theErr != noErr)        // If call failed, go to error dialog.
  204.             RedAlert("\pUnknown Error.");
  205.     }
  206.     else                            // Call error dialog if no device handle.
  207.         RedAlert("\pUnknown Error.");
  208. }
  209.  
  210. //--------------------------------------------------------------  CheckEnvirons
  211.  
  212. // This is the "wrapper" function that calls all the above functions.
  213. // After calling ToolBoxInit(), Glypha will call this function to see…
  214. // if the current Mac we're running on is capable of running Glypha.
  215.  
  216. void CheckEnvirons (void)
  217. {
  218.     if (!DoWeHaveColor())            // We absolutely need Color QuickDraw.
  219.         RedAlert("\pGlypha II only runs in 256 colors.");
  220.     
  221.     if (!DoWeHaveSystem605())        // We absolutely need System 6.0.5. or more recent.
  222.         RedAlert("\pGlypha II requires System 6.0.5 or better to run.");
  223.                                     // If we passed the above 2 tests, get a…
  224.     FindOurDevice();                // handle to the main device (monitor).
  225.     
  226.     wasDepth = WhatsOurDepth();        // Find out our monitor's depth.
  227.     if (wasDepth != 8)                // If it's not 8-bit we'll need to switch depths.
  228.     {                                // Test 1st to see if monitor capable of 8-bit.
  229.         if (CanWeDisplay8Bit(thisGDevice))
  230.             SwitchToDepth(8, TRUE);    // If so, switch to 256 colors.
  231.         else                        // If not, we have to quit.
  232.             RedAlert("\pGlypha II only runs in 256 colors.");
  233.     }
  234. }
  235.  
  236. //--------------------------------------------------------------  OpenMainWindow
  237.  
  238. // This is a simple function that merely opens up a large black window and…
  239. // centers it in the monitor.  It assumes a 'WIND' (window) resource, which if you…
  240. // look at the resource file in ResEdit, you'll find it also has a 'WCTB'…
  241. // (window color table) resource.  The 'WCTB' resource specifies a content…
  242. // color of black - thus this window comes up black.
  243.  
  244. void OpenMainWindow (void)
  245. {
  246.     SetRect(&mainWindowRect, 0, 0, 640, 460);            // Our window size.
  247.     mainWindow = GetNewCWindow(128, 0L, kPutInFront);    // Load window from resource.
  248.                                                         // Make it the right size.
  249.     SizeWindow((GrafPtr)mainWindow, mainWindowRect.right - mainWindowRect.left, 
  250.             mainWindowRect.bottom - mainWindowRect.top, FALSE);
  251.                                                         // Center the window.
  252.     MoveWindow((GrafPtr)mainWindow, (qd.screenBits.bounds.right - 640) / 2, 
  253.             ((qd.screenBits.bounds.bottom - 480) / 2) + LMGetMBarHeight(), TRUE);
  254.     ShowWindow((GrafPtr)mainWindow);                    // Now display it.
  255.     SetPort((GrafPtr)mainWindow);                        // Make its port current.
  256.     ClipRect(&mainWindowRect);                            // Set its clip region.
  257.     CopyRgn(mainWindow->clipRgn, mainWindow->visRgn);    // Set its visRgn.
  258.     ForeColor(blackColor);                                // Set its pen color to black.
  259.     BackColor(whiteColor);                                // Set background color white.
  260. }
  261.  
  262. //--------------------------------------------------------------  InitMenubar
  263.  
  264. // This function loads up the menus and displays the menu bar.
  265.  
  266. void InitMenubar (void)
  267. {
  268.     appleMenu = GetMenu(128);        // Get the Apple menu (About…).
  269.     if (appleMenu == 0L)            // See that it loaded okay.
  270.         RedAlert("\pCouldn't Load Menus Error");
  271.     AddResMenu(appleMenu, 'DRVR');    // Add Desk Accesories.
  272.     InsertMenu(appleMenu, 0);        // Add to menu bar.
  273.     
  274.     gameMenu = GetMenu(129);        // Next load the Game menu.
  275.     if (gameMenu == 0L)                // Make sure it loaded as well.
  276.         RedAlert("\pCouldn't Load Menus Error");
  277.     InsertMenu(gameMenu, 0);        // And add it next to the menu bar.
  278.     
  279.     optionsMenu = GetMenu(130);        // Finally load the Options menu.
  280.     if (optionsMenu == 0L)
  281.         RedAlert("\pCouldn't Load Menus Error");
  282.     InsertMenu(optionsMenu, 0);        // And insert it.
  283.     
  284.     DrawMenuBar();                    // Now display the menu bar.
  285. }
  286.  
  287. //--------------------------------------------------------------  InitVariables
  288.  
  289. // This function is called only once.  It initializes all the global variables…
  290. // used by Glypha.  It may not in fact be necessary to initialize many of these…
  291. // (your compiler should ensure that all globals are set to zero when your app…
  292. // launches), but it's a good idea to NEVER TRUST YOUR COMPILER.
  293.  
  294. void InitVariables (void)
  295. {
  296.     short        i;
  297.     
  298.     quitting = FALSE;    // I won't describe every one of these, many are…
  299.     playing = FALSE;    // self explanatory.  Suffice it to say that first…
  300.     pausing = FALSE;    // I'm initializing all the Boolean variables.
  301.     canPlay = FALSE;
  302.     whichList = TRUE;
  303.     helpOpen = FALSE;
  304.     scoresOpen = FALSE;
  305.     openTheScores = FALSE;
  306.     
  307.     numLedges = 3;                    // Number of ledges in the "arena".
  308.     beginOnLevel = 1;                // First level to begin playing.
  309.     levelOn = 0;                    // Level number player is on.
  310.     livesLeft = kInitNumLives;        // Number of player lives.
  311.     theScore = 0L;                    // Player's score (notice it's a long!).
  312.     wasTensOfThousands = 0L;        // For tracking when player gets an extra life.
  313.     GenerateLightning(320, 240);    // Initialize a lightning bolt.
  314.     
  315.     backSrcRect = mainWindowRect;    // Create background offscreen pixmap.
  316.     ZeroRectCorner(&backSrcRect);
  317.     backSrcMap = 0L;
  318.     CreateOffScreenPixMap(&backSrcRect, &backSrcMap);
  319.     LoadGraphic(kBackgroundPictID);
  320.     
  321.     workSrcRect = mainWindowRect;    // Create "work" offscreen pixmap.
  322.     ZeroRectCorner(&workSrcRect);
  323.     workSrcMap = 0L;
  324.     CreateOffScreenPixMap(&workSrcRect, &workSrcMap);
  325.     
  326.     SetRect(&obSrcRect, 0, 0, 20, 418);
  327.     obeliskSrcMap = 0L;                // Create pixmap to hold "obelisk" graphics.
  328.     CreateOffScreenPixMap(&obSrcRect, &obeliskSrcMap);
  329.     LoadGraphic(kObeliskPictID);
  330.     SetRect(&obeliskRects[0], 0, 0, 20, 209);
  331.     OffsetRect(&obeliskRects[0], 0, 0);
  332.     SetRect(&obeliskRects[1], 0, 0, 20, 209);
  333.     OffsetRect(&obeliskRects[1], 0, 209);
  334.     SetRect(&obeliskRects[2], 0, 0, 20, 209);
  335.     OffsetRect(&obeliskRects[2], 161, 250);
  336.     SetRect(&obeliskRects[3], 0, 0, 20, 209);
  337.     OffsetRect(&obeliskRects[3], 457, 250);
  338.     
  339.     SetRect(&playerSrcRect, 0, 0, 48, 436);
  340.     playerSrcMap = 0L;                // Create pixmap to hold "player" graphics.
  341.     CreateOffScreenPixMap(&playerSrcRect, &playerSrcMap);
  342.     LoadGraphic(kPlayerPictID);
  343.     playerMaskMap = 0L;
  344.     CreateOffScreenBitMap(&playerSrcRect, &playerMaskMap);
  345.     LoadGraphic(kPlayerMaskID);
  346.     
  347.     SetRect(&enemyWalkSrcRect, 0, 0, 48, 576);
  348.     enemyWalkSrcMap = 0L;            // Create pixmap to hold "enemy" graphics.
  349.     CreateOffScreenPixMap(&enemyWalkSrcRect, &enemyWalkSrcMap);
  350.     LoadGraphic(kEnemyWalkPictID);
  351.     enemyWalkMaskMap = 0L;
  352.     CreateOffScreenBitMap(&enemyWalkSrcRect, &enemyWalkMaskMap);
  353.     LoadGraphic(kEnemyWalkMaskID);
  354.     SetRect(&enemyFlySrcRect, 0, 0, 64, 480);
  355.     enemyFlySrcMap = 0L;
  356.     CreateOffScreenPixMap(&enemyFlySrcRect, &enemyFlySrcMap);
  357.     LoadGraphic(kEnemyFlyPictID);
  358.     enemyFlyMaskMap = 0L;
  359.     CreateOffScreenBitMap(&enemyFlySrcRect, &enemyFlyMaskMap);
  360.     LoadGraphic(kEnemyFlyMaskID);
  361.     for (i = 0; i < 12; i++)
  362.     {                                // Set up enemy source rectangles.
  363.         SetRect(&enemyRects[i], 0, 0, 48, 48);
  364.         OffsetRect(&enemyRects[i], 0, 48 * i);
  365.     }
  366.     for (i = 0; i < 12; i++)
  367.     {
  368.         SetRect(&enemyRects[i + 12], 0, 0, 64, 40);
  369.         OffsetRect(&enemyRects[i + 12], 0, 40 * i);
  370.     }
  371.     SetRect(&enemyInitRects[0], 0, 0, 48, 1);
  372.     OffsetRect(&enemyInitRects[0], 72, 284);
  373.     SetRect(&enemyInitRects[1], 0, 0, 48, 1);
  374.     OffsetRect(&enemyInitRects[1], 520, 284);
  375.     SetRect(&enemyInitRects[2], 0, 0, 48, 1);
  376.     OffsetRect(&enemyInitRects[2], 72, 105);
  377.     SetRect(&enemyInitRects[3], 0, 0, 48, 1);
  378.     OffsetRect(&enemyInitRects[3], 520, 105);
  379.     SetRect(&enemyInitRects[4], 0, 0, 48, 1);
  380.     OffsetRect(&enemyInitRects[4], 296, 190);
  381.     
  382.     SetRect(&eggSrcRect, 0, 0, 24, 24);
  383.     eggSrcMap = 0L;                    // Create pixmap to hold "egg" graphics.
  384.     CreateOffScreenPixMap(&eggSrcRect, &eggSrcMap);
  385.     LoadGraphic(kEggPictID);
  386.     eggMaskMap = 0L;
  387.     CreateOffScreenBitMap(&eggSrcRect, &eggMaskMap);
  388.     LoadGraphic(kEggMaskID);
  389.     
  390.     SetRect(&eyeSrcRect, 0, 0, 48, 124);
  391.     eyeSrcMap = 0L;                    // Create pixmap to hold "eye" graphics.
  392.     CreateOffScreenPixMap(&eyeSrcRect, &eyeSrcMap);
  393.     LoadGraphic(kEyePictID);
  394.     eyeMaskMap = 0L;
  395.     CreateOffScreenBitMap(&eyeSrcRect, &eyeMaskMap);
  396.     LoadGraphic(kEyeMaskID);
  397.     for (i = 0; i < 4; i++)
  398.     {
  399.         SetRect(&eyeRects[i], 0, 0, 48, 31);
  400.         OffsetRect(&eyeRects[i], 0, i * 31);
  401.     }
  402.     
  403.     SetRect(&handSrcRect, 0, 0, 56, 114);
  404.     handSrcMap = 0L;                // Create pixmap to hold "mummy hand" graphics.
  405.     CreateOffScreenPixMap(&handSrcRect, &handSrcMap);
  406.     LoadGraphic(kHandPictID);
  407.     handMaskMap = 0L;
  408.     CreateOffScreenBitMap(&handSrcRect, &handMaskMap);
  409.     LoadGraphic(kHandMaskID);
  410.     SetRect(&handRects[0], 0, 0, 56, 57);
  411.     OffsetRect(&handRects[0], 0, 0);
  412.     SetRect(&handRects[1], 0, 0, 56, 57);
  413.     OffsetRect(&handRects[1], 0, 57);
  414.     SetRect(&grabZone, 0, 0, 96, 108);
  415.     OffsetRect(&grabZone, 48, 352);
  416.     
  417.     SetRect(&idleSrcRect, 0, 0, 48, 48);
  418.     idleSrcMap = 0L;                // Create pixmap to hold "shielded player".
  419.     CreateOffScreenPixMap(&idleSrcRect, &idleSrcMap);
  420.     LoadGraphic(kIdlePictID);
  421.     
  422.     SetRect(&flameSrcRect, 0, 0, 16, 64);
  423.     flameSrcMap = 0L;                // Create pixmap to hold "torch" graphics.
  424.     CreateOffScreenPixMap(&flameSrcRect, &flameSrcMap);
  425.     LoadGraphic(kFlamePictID);
  426.     SetRect(&flameDestRects[0], 0, 0, 16, 16);
  427.     OffsetRect(&flameDestRects[0], 87, 325);
  428.     SetRect(&flameDestRects[1], 0, 0, 16, 16);
  429.     OffsetRect(&flameDestRects[1], 535, 325);
  430.     for (i = 0; i < 4; i++)
  431.     {
  432.         SetRect(&flameRects[i], 0, 0, 16, 16);
  433.         OffsetRect(&flameRects[i], 0, i * 16);
  434.     }
  435.     
  436.     SetRect(&numberSrcRect, 0, 0, 8, 121);
  437.     numberSrcMap = 0L;                // Create pixmap to hold "score numbers".
  438.     CreateOffScreenPixMap(&numberSrcRect, &numberSrcMap);
  439.     LoadGraphic(kNumberPictID);
  440.     for (i = 0; i < 11; i++)
  441.     {
  442.         SetRect(&numbersSrc[i], 0, 0, 8, 11);
  443.         OffsetRect(&numbersSrc[i], 0, 11 * i);
  444.     }
  445.     SetRect(&numbersDest[0], 0, 0, 8, 11);    // # of lives digit 1
  446.     OffsetRect(&numbersDest[0], 229, 443);
  447.     SetRect(&numbersDest[1], 0, 0, 8, 11);    // # of lives digit 2
  448.     OffsetRect(&numbersDest[1], 237, 443);
  449.     SetRect(&numbersDest[2], 0, 0, 8, 11);    // score digit 1
  450.     OffsetRect(&numbersDest[2], 293, 443);
  451.     SetRect(&numbersDest[3], 0, 0, 8, 11);    // score digit 2
  452.     OffsetRect(&numbersDest[3], 301, 443);
  453.     SetRect(&numbersDest[4], 0, 0, 8, 11);    // score digit 3
  454.     OffsetRect(&numbersDest[4], 309, 443);
  455.     SetRect(&numbersDest[5], 0, 0, 8, 11);    // score digit 4
  456.     OffsetRect(&numbersDest[5], 317, 443);
  457.     SetRect(&numbersDest[6], 0, 0, 8, 11);    // score digit 5
  458.     OffsetRect(&numbersDest[6], 325, 443);
  459.     SetRect(&numbersDest[7], 0, 0, 8, 11);    // score digit 6
  460.     OffsetRect(&numbersDest[7], 333, 443);
  461.     SetRect(&numbersDest[8], 0, 0, 8, 11);    // # of level digit 1
  462.     OffsetRect(&numbersDest[8], 381, 443);
  463.     SetRect(&numbersDest[9], 0, 0, 8, 11);    // # of level digit 2
  464.     OffsetRect(&numbersDest[9], 389, 443);
  465.     SetRect(&numbersDest[10], 0, 0, 8, 11);    // # of level digit 3
  466.     OffsetRect(&numbersDest[10], 397, 443);
  467.     
  468.     SetRect(&playerRects[0], 0, 0, 48, 37);
  469.     OffsetRect(&playerRects[0], 0, 0);
  470.     SetRect(&playerRects[1], 0, 0, 48, 37);
  471.     OffsetRect(&playerRects[1], 0, 37);
  472.     SetRect(&playerRects[2], 0, 0, 48, 37);
  473.     OffsetRect(&playerRects[2], 0, 74);
  474.     SetRect(&playerRects[3], 0, 0, 48, 37);
  475.     OffsetRect(&playerRects[3], 0, 111);
  476.     SetRect(&playerRects[4], 0, 0, 48, 48);
  477.     OffsetRect(&playerRects[4], 0, 148);
  478.     SetRect(&playerRects[5], 0, 0, 48, 48);
  479.     OffsetRect(&playerRects[5], 0, 196);
  480.     SetRect(&playerRects[6], 0, 0, 48, 48);
  481.     OffsetRect(&playerRects[6], 0, 244);
  482.     SetRect(&playerRects[7], 0, 0, 48, 48);
  483.     OffsetRect(&playerRects[7], 0, 292);
  484.     SetRect(&playerRects[8], 0, 0, 48, 37);        // falling bones rt.
  485.     OffsetRect(&playerRects[8], 0, 340);
  486.     SetRect(&playerRects[9], 0, 0, 48, 37);        // falling bones lf.
  487.     OffsetRect(&playerRects[9], 0, 377);
  488.     SetRect(&playerRects[10], 0, 0, 48, 22);    // pile of bones
  489.     OffsetRect(&playerRects[10], 0, 414);
  490.     
  491.     MoveTo(0, 0);            // Generate clipping region that excludes the obelisks.
  492.     playRgn = NewRgn();        // Create empty new region.
  493.     OpenRgn();                // Open region for definition.
  494.     LineTo(0, 450);            // Walk around the vertices of our region.
  495.     LineTo(161, 450);
  496.     LineTo(161, 269);
  497.     LineTo(172, 250);
  498.     LineTo(182, 269);
  499.     LineTo(182, 450);
  500.     LineTo(457, 450);
  501.     LineTo(457, 269);
  502.     LineTo(468, 250);
  503.     LineTo(478, 269);
  504.     LineTo(478, 450);
  505.     LineTo(640, 450);
  506.     LineTo(640, 0);
  507.     LineTo(0, 0);
  508.     CloseRgn(playRgn);        // Stop region definition.
  509.     MoveHHi((Handle)playRgn);
  510.     HLock((Handle)playRgn);
  511.     
  512.     SetRect(&platformSrcRect, 0, 0, 191, 192);
  513.     platformSrcMap = 0L;    // Create pixmap to hold "platform" graphic.
  514.     CreateOffScreenPixMap(&platformSrcRect, &platformSrcMap);
  515.     LoadGraphic(kPlatformPictID);
  516.     for (i = 0; i < 6; i++)
  517.     {
  518.         SetRect(&platformCopyRects[i], 0, 0, 191, 32);
  519.         OffsetRect(&platformCopyRects[i], 0, 32 * i);
  520.     }
  521.     SetRect(&platformCopyRects[6], 233, 190, 424, 222);
  522.     SetRect(&platformCopyRects[7], 0, 105, 191, 137);
  523.     SetRect(&platformCopyRects[8], 449, 105, 640, 137);
  524.                             // These are the platforms.  See diagram for numbering.
  525.     SetRect(&platformRects[0], 206, 424, 433, 438);        //_______________
  526.     SetRect(&platformRects[1], -256, 284, 149, 298);    //
  527.     SetRect(&platformRects[2], 490, 284, 896, 298);        //--3--     --4--
  528.     SetRect(&platformRects[3], -256, 105, 149, 119);    //     --5--
  529.     SetRect(&platformRects[4], 490, 105, 896, 119);        //--1--     --2--
  530.     SetRect(&platformRects[5], 233, 190, 407, 204);        //_____--0--_____
  531.     
  532.     for (i = 0; i < 6; i++)
  533.     {                        // "Hot rects" to sense if player landing on platform.
  534.         touchDownRects[i] = platformRects[i];
  535.         touchDownRects[i].left += 23;
  536.         touchDownRects[i].right -= 23;
  537.         touchDownRects[i].bottom = touchDownRects[i].top;
  538.         touchDownRects[i].top = touchDownRects[i].bottom - 11;
  539.     }
  540.     
  541.     SetRect(&helpSrcRect, 0, 0, 231, 398);
  542.     helpSrcMap = 0L;        // Create pixmap to hold "help screen" graphic.
  543.     CreateOffScreenPixMap(&helpSrcRect, &helpSrcMap);
  544.     LoadGraphic(kHelpPictID);
  545.     
  546.     SetPort((GrafPtr)mainWindow);
  547. }
  548.  
  549. //--------------------------------------------------------------  ShutItDown
  550.  
  551. // This function is called when the player has chosen to quit Glypha.
  552. // It "should" probably do more, but in fact all it does is to restore…
  553. // their Mac's monitor back to the depth it was before they launched…
  554. // Glypha (recall that we may have changed it to 8-bit).
  555.  
  556. void ShutItDown (void)
  557. {
  558.     if (wasDepth != WhatsOurDepth())    // Need only switch if wasn't 8-bit.
  559.         SwitchToDepth(wasDepth, TRUE);    // Switch back to out "old" depth.
  560. }
  561.  
  562.